issue (complexity): Consider creating a helper function to encapsulate subprocess execution and error handling to avoid repetition across multiple functions like run_bumpversion, update_uv_lock, and generate_changelog, improving code maintainability and readability.

Actionable Recommendation:

Consolidate the repeated subprocess invocations and error handling into a helper function. This centralizes the logic and reduces duplication.

Steps:

1. Create a helper function:

   def run_command(cmd, success_msg=None, error_msg="命令执行失败"):
       try:
           result = subprocess.run(cmd, capture_output=True, text=True)
           if result.returncode != 0:
               print(f"❌ {error_msg}: {result.stderr}")
               sys.exit(1)
           if success_msg:
               print(success_msg)
           return result.stdout
       except Exception as e:
           print(f"❌ {error_msg}: {e}")
           sys.exit(1)

2. Refactor run_bumpversion:

   def run_bumpversion(part, new_version=None):
       cmd = ["bump2version"]
       if new_version:
           cmd += ["--new-version", new_version]
       cmd.append(part)
       run_command(cmd, success_msg="✅ 版本号已更新", error_msg="bump2version 执行失败")
       return True

3. Refactor similar functions (e.g., update_uv_lock, generate_changelog):

   def update_uv_lock():
       if not os.path.exists("uv.lock"):
           print("⚠️ 未找到 uv.lock，跳过")
           return
       run_command(["uv", "lock"], success_msg="✅ uv.lock 已更新", error_msg="uv lock 执行失败")
   
   def generate_changelog(version: str):
       cmd = ["git-cliff", "--tag", f"v{version}", "-o", "CHANGELOG.md"]
       run_command(cmd, success_msg="✅ changelog 已生成", error_msg="changelog 生成失败")

These changes keep all functionality intact while reducing repetitive error handling and subprocess logic.

issue (complexity): Consider using a dedicated version file and relative imports to simplify version information handling and avoid modifying sys.path.

To reduce complexity without reverting functionality, consider removing the temporary sys.path manipulation by placing your version information in a dedicated file within the package. This lets you use a standard relative import and isolates fallback logic. For example:

1. Create a dedicated version file
   In core/version.py, define:

   __version__ = "1.2.3"  # your current version

2. Import version info using relative import
   Replace the dynamic sys.path adjustment with a relative import:

   try:
       from core.version import __version__
   except ImportError as e:
       logger.error(f"导入版本信息失败: {e}")
       __version__ = fallback_version()

3. Isolate fallback logic
   Define a helper for fallback reading:

   def fallback_version() -> str:
       try:
           import tomli
           with open(Path(__file__).parent.parent / "pyproject.toml", "rb") as f:
               data = tomli.load(f)
               return data.get("project", {}).get("version", "0.0.0")
       except Exception as e:
           logger.error(f"读取版本信息失败: {e}")
           return "0.0.0"

This approach eliminates temporary sys.path modifications while keeping functionality intact and simplifying error handling.

suggestion (code-quality): Remove redundant pass statement (remove-redundant-pass)

suggestion (code-quality): Replace m.group(x) with m[x] for re.Match objects (use-getitem-for-re-match-groups)

suggestion (code-quality): Merge dictionary updates via the union operator (dict-assign-update-to-union)